{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "1e75e5df",
   "metadata": {},
   "source": [
    "# Finetuning Transformers as RNNs\n",
    "\n",
    "In this notebook are implementing the paper \"Finetuning Pretrained Transformers into RNNs\" [link](https://arxiv.org/pdf/2103.13076.pdf).\n",
    "\n",
    "- **Yash Bonde**, [LinkedIn](https://www.linkedin.com/in/yash-bonde/)\n",
    "- 18th April, 2021.\n",
    "\n",
    "Brief about the paper:\n",
    "\n",
    "> Attention computation in transformer networks has quadratic complexity for sequence length, meaning that very long sequences are exorbitantly expensive to generate. This paper proposes posing the generation problem of transformer as a RNN generation resulting in linear time and fixed memory requirements. Below you can see how this works.\n",
    "\n",
    "<img src=\"https://pbs.twimg.com/media/ExST1PmXEA03vRm.jpg\">\n",
    "\n",
    "In the final section we also perform tests and visualise the results."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "f477119e",
   "metadata": {},
   "outputs": [],
   "source": [
    "import re\n",
    "import random\n",
    "import numpy as np\n",
    "from tqdm import trange\n",
    "from newspaper import Article\n",
    "\n",
    "import torch\n",
    "from torch import nn\n",
    "from torch.nn import functional as F\n",
    "from torch.utils.data import DataLoader, TensorDataset\n",
    "\n",
    "from transformers.models import gpt2\n",
    "from transformers import GPT2Config, GPT2LMHeadModel\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "fcd8e376",
   "metadata": {},
   "outputs": [],
   "source": [
    "article = Article(\"https://en.wikipedia.org/wiki/India\")\n",
    "article.download()\n",
    "article.parse()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "7f295624",
   "metadata": {},
   "outputs": [],
   "source": [
    "sample_text = re.sub(\"[^a-z0-9\\s]\", \"\", article.text.lower())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "a8624c6f",
   "metadata": {},
   "outputs": [],
   "source": [
    "total_tokens = len(sample_text)\n",
    "unq = sorted(set(sample_text))\n",
    "vocab_size = len(unq)\n",
    "vocab = {k:i for i,k in enumerate(unq)}\n",
    "inv_vocab = {i:k for i,k in enumerate(unq)}\n",
    "# vocab"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "995a081a",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "746"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "batches = [sample_text[i:i+100] for i in range(0, len(sample_text), 100)][:-1]\n",
    "batches = torch.from_numpy(np.array([[vocab[y] for y in x] for x in batches])).long()\n",
    "ds = TensorDataset(batches)\n",
    "len(batches)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "50cb274b",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2864"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tinyconf = GPT2Config(\n",
    "  vocab_size=vocab_size,\n",
    "  n_positions=batches.shape[-1],\n",
    "  n_ctx=batches.shape[-1],\n",
    "  n_embd=8,\n",
    "  n_layer=2,\n",
    "  n_head=2\n",
    ")\n",
    "model = GPT2LMHeadModel(tinyconf)\n",
    "model.init_weights()\n",
    "model.num_parameters()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0593c63a",
   "metadata": {},
   "source": [
    "## Train `transformer`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "id": "1871707a",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Loss: 2.492: 100%|██████████| 100/100 [01:52<00:00,  1.13s/it]\n"
     ]
    }
   ],
   "source": [
    "optim = torch.optim.Adam(model.parameters(), lr = 0.001)\n",
    "pbar = trange(100)\n",
    "all_losses = [-1]\n",
    "for _ in pbar:\n",
    "  dl = DataLoader(ds, shuffle = True, batch_size = 32)\n",
    "  for x in dl:\n",
    "    pbar.set_description(f\"Loss: {all_losses[-1]:.3f}\")\n",
    "    output = model(input_ids = x[0], labels = x[0])\n",
    "    all_losses.append(output.loss.item())\n",
    "    \n",
    "    optim.zero_grad()\n",
    "    output.loss.backward()\n",
    "    optim.step()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "id": "d4cea2d8",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x1382642e0>]"
      ]
     },
     "execution_count": 70,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.plot(all_losses[1:])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "c7a0a382",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Setting `pad_token_id` to `eos_token_id`:50256 for open-end generation.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CPU times: user 216 ms, sys: 41 ms, total: 257 ms\n",
      "Wall time: 224 ms\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "model.eval()\n",
    "outputs = model.generate(\n",
    "  input_ids = ds[0][0][:10].unsqueeze(0),\n",
    "  max_length=100,\n",
    "  do_sample=True,\n",
    "  num_return_sequences=10,\n",
    "  top_k=10,\n",
    "  top_p=0.9\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "id": "079f764b",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['this artice alan ir tredentofre plistr we c',\n",
       " 'this artices ach a pin thindila thansiachas',\n",
       " 'this artice ciss adule on a cica onan a pun',\n",
       " 'this articitensthas ies t whin pertengelin ',\n",
       " 'this articre worinasad a artet bin pa cicof',\n",
       " 'this artices corlen iarenan ste orondis ill',\n",
       " 'this artic t bhin anistora of wirinanarac o',\n",
       " 'this articia bet t be thathiry pins tan o a',\n",
       " 'this articedadins com to blame b ofoled the',\n",
       " 'this articuried bing a of olof bofrinastis ']"
      ]
     },
     "execution_count": 91,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "[\"\".join([inv_vocab[x] for x in seq]) for seq in outputs.tolist()]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "id": "4b0e766f",
   "metadata": {},
   "outputs": [],
   "source": [
    "torch.save(model.state_dict(), \"./tinywiki.pt\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b8f5ce3c",
   "metadata": {},
   "source": [
    "## Train `LSTM`\n",
    "\n",
    "Train a small LSTM just to check can we actually train this thing correctly."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "54e9fbae",
   "metadata": {},
   "outputs": [],
   "source": [
    "class LSTMModel(nn.Module):\n",
    "  def __init__(self, config, n_layers):\n",
    "    super().__init__()\n",
    "    self.wte = nn.Embedding(config.vocab_size, config.n_embd)\n",
    "    self.lstm = nn.LSTM(config.n_embd, config.n_embd, num_layers = n_layers, batch_first = True, )\n",
    "    self.lm_head = nn.Linear(config.n_embd, config.vocab_size)\n",
    "    \n",
    "  def num_parameters(self):\n",
    "    return sum(p.numel() for p in self.parameters())\n",
    "    \n",
    "  def forward(self, input_ids, hidden_state):\n",
    "    emb = self.wte(input_ids)\n",
    "    emb, hidden_state = self.lstm(emb, hidden_state)\n",
    "    logits = self.lm_head(emb)\n",
    "    return logits, hidden_state"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "0592c890",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2950"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# n_layers = 4 gives the closes approximation to the\n",
    "# transformer model\n",
    "n_layers = 4\n",
    "model = LSTMModel(tinyconf, n_layers = n_layers)\n",
    "model.num_parameters()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "6e9d6f3e",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Loss: 2.308: 100%|██████████| 250/250 [07:01<00:00,  1.69s/it]\n"
     ]
    }
   ],
   "source": [
    "optim = torch.optim.Adam(model.parameters(), lr = 0.001)\n",
    "pbar = trange(250)\n",
    "all_losses = [-1]\n",
    "ds = TensorDataset(batches)\n",
    "num_directions = 2 if model.lstm.bidirectional else 1\n",
    "for _ in pbar:\n",
    "  dl = DataLoader(ds, shuffle = True, batch_size = 32)\n",
    "  for i, x in enumerate(dl):\n",
    "    x = x[0]\n",
    "    pbar.set_description(f\"Loss: {all_losses[-1]:.3f}\")\n",
    "\n",
    "    # there are 2 \"internal\" states of LSTM cell\n",
    "    #   - hidden_state: hidden state for each element of the batch\n",
    "    #   - cell_state: cell state for each element of the batch\n",
    "    # each having shape:\n",
    "    #   [num_layers * num_directions, batch, hidden_size]\n",
    "    hidden_state = [\n",
    "      torch.zeros((n_layers * num_directions, x.shape[0], tinyconf.n_embd)).float(),\n",
    "      torch.zeros((n_layers * num_directions, x.shape[0], tinyconf.n_embd)).float()\n",
    "    ]\n",
    "    # print(x[:, :-1].shape, [x.shape for x in hidden_state])\n",
    "    output, hidden_state = model(x[:, :-1], hidden_state)\n",
    "    labels = x[:, 1:].contiguous().view(-1)\n",
    "    output = output.contiguous().view(-1, output.shape[-1])\n",
    "    loss = F.cross_entropy(output, labels)\n",
    "      \n",
    "    all_losses.append(loss.item())\n",
    "\n",
    "    optim.zero_grad()\n",
    "    loss.backward()\n",
    "    optim.step()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "53152ac4",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x12eb68190>]"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.plot(all_losses[1:])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "22e83647",
   "metadata": {},
   "outputs": [],
   "source": [
    "hidden_state = [torch.randn((4, x.shape[1]-1, tinyconf.n_embd)).float() for _ in range(2)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "0c616b17",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([[31, 19, 20, 30,  1, 12, 29, 31, 20, 14]])"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ds[0][0][:10].unsqueeze(0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "81465cca",
   "metadata": {},
   "outputs": [],
   "source": [
    "with torch.no_grad():\n",
    "  num_return_sequences = 10\n",
    "  hidden_state = [\n",
    "    torch.zeros((n_layers * num_directions, x.shape[0], tinyconf.n_embd)).float(),\n",
    "    torch.zeros((n_layers * num_directions, x.shape[0], tinyconf.n_embd)).float()\n",
    "  ]\n",
    "  input_ids = torch.tile(ds[0][0][:10], [num_return_sequences, 1])\n",
    "  for _ in range(43):\n",
    "    output, hidden_state = model(input_ids, hidden_state)\n",
    "    logits = output[:, -1].softmax(-1)\n",
    "    x = torch.multinomial(logits, 1)\n",
    "    input_ids = torch.cat([input_ids, x], dim = 1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "980c411a",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['this articatcas thar mijghgfe gotity ihe ancal gn exc',\n",
       " 'this articlar thotiien of thg mal19\\n\\nanfal ar siordie',\n",
       " 'this articy cacicin as nnl jekiie whael tbior sin ihe',\n",
       " 'this articked gial to a tli sorantateoaupulmeg fsomtc',\n",
       " 'this articls4\\n30 pyliwan wolg ceraatkiudt yn girten i',\n",
       " 'this artich fentiants reciere notpernles maldeiene ka',\n",
       " 'this articiks al denatieriejral iher coplts cerderch ',\n",
       " 'this artice\\n\\nof 21 bhect srunnajih wtutebls enen in s',\n",
       " 'this artic sroopmert basamia oumion an ihhawatted mod',\n",
       " 'this articiuduss in \\nnaih jtartstgssek cotdurriopsoct']"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "[\"\".join([inv_vocab[x] for x in seq]) for seq in input_ids.tolist()]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fab7cdd4",
   "metadata": {},
   "source": [
    "## Train `T2R`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "1d0b49e5",
   "metadata": {},
   "outputs": [],
   "source": [
    "class RNNAttention(nn.Module):\n",
    "  # this is at the heart of T2R framework\n",
    "  def __init__(self, config):\n",
    "    super().__init__()\n",
    "    self.config = config\n",
    "    \n",
    "    nx = config.n_embd\n",
    "    \n",
    "    \n",
    "    self.c_attn = gpt2.modeling_gpt2.Conv1D(3 * nx, nx)\n",
    "    self.c_proj = gpt2.modeling_gpt2.Conv1D(nx, nx)\n",
    "\n",
    "    head_size = config.n_embd // config.n_head\n",
    "    nx_rnn = head_size\n",
    "    \n",
    "    self.phi = nn.Sequential(\n",
    "      nn.Linear(head_size, nx_rnn),\n",
    "      nn.ReLU()\n",
    "    )\n",
    "    \n",
    "  def split_heads(self, x, k=False):\n",
    "    new_x_shape = x.size()[:-1] + (self.config.n_head, x.size(-1) // self.config.n_head)\n",
    "    x = x.view(*new_x_shape)  # in Tensorflow implem: fct split_states\n",
    "    if k:\n",
    "      return x.permute(0, 2, 3, 1)  # (batch, head, head_features, seq_length)\n",
    "    else:\n",
    "      return x.permute(0, 2, 1, 3)  # (batch, head, seq_length, head_features)\n",
    "    \n",
    "  def merge_heads(self, x):\n",
    "    x = x.permute(0, 2, 1, 3).contiguous()\n",
    "    new_x_shape = x.size()[:-2] + (x.size(-2) * x.size(-1),)\n",
    "    return x.view(*new_x_shape)  # in Tensorflow implem: fct merge_states\n",
    "    \n",
    "  def forward(self, x, attention_mask):\n",
    "    # during training we only fine-tune the function phi\n",
    "    q, k, v = self.c_attn(x).split(self.config.n_embd, dim=2)\n",
    "    q = self.split_heads(q)\n",
    "    k = self.split_heads(k) # don't permute in key, phi won't work\n",
    "    v = self.split_heads(v)\n",
    "\n",
    "    phi_k = self.phi(k).permute((0, 1, 3, 2)) # [B,H,E//H,S]\n",
    "    phi_q = self.phi(q) # [B,H,S,E//H]\n",
    "    w = phi_q @ phi_k # [B,H,S,S]\n",
    "    \n",
    "    if attention_mask is not None:\n",
    "      w = w + attention_mask\n",
    "    \n",
    "    out = w @ v # [B,H,S,E//H]\n",
    "    \n",
    "    out = self.merge_heads(out) # [B,S,E]\n",
    "    out = self.c_proj(out)\n",
    "    return out"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "ed4e99d8",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Block(nn.Module):\n",
    "  def __init__(self, config):\n",
    "    super().__init__()\n",
    "    \n",
    "    inner_dim = config.n_inner if config.n_inner is not None else 4 * config.n_embd\n",
    "    self.ln_1 = nn.LayerNorm(config.n_embd, eps=config.layer_norm_epsilon)\n",
    "    self.attn = RNNAttention(config)\n",
    "    # self.attn = gpt2.modeling_gpt2.Attention(config.n_embd, config.n_ctx, config)\n",
    "    self.ln_2 = nn.LayerNorm(config.n_embd, eps=config.layer_norm_epsilon)\n",
    "    self.mlp = gpt2.modeling_gpt2.MLP(inner_dim, config)\n",
    "    \n",
    "  def forward(self, hidden_states, attention_mask = None):\n",
    "    attn_outputs = self.attn(self.ln_1(hidden_states), attention_mask)\n",
    "    if isinstance(attn_outputs, tuple):\n",
    "      attn_outputs = attn_outputs[0]\n",
    "    # NOTE: this operation is not correct and will cause errors during loss.backward()\n",
    "    # hidden_states += attn_outputs\n",
    "    # because \"+=\" causes inplace update and not create a new variable\n",
    "    # and unless a new variable is created backprop will fail.\n",
    "    hidden_states = hidden_states + attn_outputs\n",
    "    mlp_states = self.mlp(self.ln_2(hidden_states))\n",
    "    hidden_states = hidden_states +  mlp_states\n",
    "    return hidden_states\n",
    "\n",
    "\n",
    "class T2R(nn.Module):\n",
    "  def __init__(self, config):\n",
    "    super().__init__()\n",
    "    \n",
    "    self.wte = nn.Embedding(config.vocab_size, config.n_embd)\n",
    "    self.wpe = nn.Embedding(config.n_positions, config.n_embd)\n",
    "    self.drop = nn.Dropout(config.embd_pdrop)\n",
    "    self.h = nn.ModuleList([Block(config) for _ in range(config.n_layer)])\n",
    "    self.ln_f = nn.LayerNorm(config.n_embd, eps=config.layer_norm_epsilon)\n",
    "    self.lm_head = nn.Linear(config.n_embd, config.vocab_size, bias = False)\n",
    "    \n",
    "  def forward(self, x, attention_mask = None):\n",
    "    \n",
    "    # Attention mask.\n",
    "    if attention_mask is not None:\n",
    "        assert batch_size > 0, \"batch_size has to be defined and > 0\"\n",
    "        attention_mask = attention_mask.view(batch_size, -1)\n",
    "        # We create a 3D attention mask from a 2D tensor mask.\n",
    "        # Sizes are [batch_size, 1, 1, to_seq_length]\n",
    "        # So we can broadcast to [batch_size, num_heads, from_seq_length, to_seq_length]\n",
    "        # this attention mask is more simple than the triangular masking of causal attention\n",
    "        # used in OpenAI GPT, we just need to prepare the broadcast dimension here.\n",
    "        attention_mask = attention_mask[:, None, None, :]\n",
    "\n",
    "        # Since attention_mask is 1.0 for positions we want to attend and 0.0 for\n",
    "        # masked positions, this operation will create a tensor which is 0.0 for\n",
    "        # positions we want to attend and -10000.0 for masked positions.\n",
    "        # Since we are adding it to the raw scores before the softmax, this is\n",
    "        # effectively the same as removing these entirely.\n",
    "        attention_mask = attention_mask.to(dtype=self.dtype)  # fp16 compatibility\n",
    "        attention_mask = (1.0 - attention_mask) * -10000.0\n",
    "        \n",
    "    device = input_ids.device if input_ids is not None else inputs_embeds.device\n",
    "    position_ids = torch.arange(0, x.shape[-1], dtype=torch.long, device=device)\n",
    "    position_ids = position_ids.unsqueeze(0).view(-1, x.shape[-1])\n",
    "    \n",
    "    inputs_embeds = self.wte(x)\n",
    "    position_embeds = self.wpe(position_ids)\n",
    "    hidden_states = inputs_embeds + position_embeds\n",
    "    hidden_states = self.drop(hidden_states)\n",
    "    \n",
    "    for i, block in enumerate(self.h):\n",
    "      hidden_states = block(hidden_states, attention_mask)\n",
    "    \n",
    "    output = self.ln_f(hidden_states)\n",
    "    output = self.lm_head(output)\n",
    "    return output"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "e2f20c26",
   "metadata": {},
   "outputs": [],
   "source": [
    "t2r = T2R(tinyconf)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 678,
   "id": "dd5624f0",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "torch.Size([1, 100, 38])"
      ]
     },
     "execution_count": 678,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "t2r(ds[10][0].unsqueeze(0)).shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 679,
   "id": "d6abd33e",
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Loss: 2.507: 100%|██████████| 100/100 [04:54<00:00,  2.94s/it]\n"
     ]
    }
   ],
   "source": [
    "optim = torch.optim.Adam(t2r.parameters(), lr = 0.001)\n",
    "pbar = trange(100)\n",
    "all_losses = [-1]\n",
    "for _ in pbar:\n",
    "  dl = DataLoader(ds, shuffle = True, batch_size = 32)\n",
    "  for x in dl:\n",
    "    with torch.autograd.set_detect_anomaly(True):\n",
    "      x = x[0]\n",
    "      pbar.set_description(f\"Loss: {all_losses[-1]:.3f}\")\n",
    "      output = t2r(x[:, :-1])\n",
    "      output = output.contiguous().view(-1, output.shape[-1])\n",
    "      labels = x[:, 1:].contiguous().view(-1)\n",
    "      loss = F.cross_entropy(output, labels)\n",
    "\n",
    "      all_losses.append(loss.item())\n",
    "\n",
    "      optim.zero_grad()\n",
    "      loss.backward()\n",
    "      optim.step()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 680,
   "id": "84d75319",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x141d4b190>]"
      ]
     },
     "execution_count": 680,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.plot(all_losses[1:])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2ac266f8",
   "metadata": {},
   "source": [
    "### `T2R` for Inference"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "7a846848",
   "metadata": {},
   "outputs": [],
   "source": [
    "class RNNAttention(nn.Module):\n",
    "  # this is at the heart of T2R framework\n",
    "  def __init__(self, config):\n",
    "    super().__init__()\n",
    "    self.config = config\n",
    "    nx = config.n_embd\n",
    "    head_size = config.n_embd // config.n_head\n",
    "    nx_rnn = head_size\n",
    "    \n",
    "    self.c_attn = gpt2.modeling_gpt2.Conv1D(3 * nx, nx)\n",
    "    self.c_proj = gpt2.modeling_gpt2.Conv1D(nx, nx)\n",
    "    self.phi = nn.Sequential(\n",
    "      nn.Linear(head_size, nx_rnn),\n",
    "      nn.ReLU()\n",
    "    )\n",
    "    \n",
    "    self.infer_ready = False\n",
    "\n",
    "  def infer_init(self):\n",
    "    \"\"\"this function performs the merging of weights + refining the graph\"\"\"\n",
    "    config = self.config\n",
    "    \n",
    "    # we get the matrices for the three qkv's by splitting the weights\n",
    "    # since we anyways split the output of qkv into q,k,v the weight and bias\n",
    "    # matrix can also be split\n",
    "    wq, wk, wv = self.c_attn.weight.data.split(self.config.n_embd, dim = 1)\n",
    "    bq, bk, bv = self.c_attn.bias.data.split(self.config.n_embd, dim = 0)\n",
    "    \n",
    "    # get the matrices for phi\n",
    "    wp = self.phi[0].weight.data # [n_embd // n_head, nx_rnn]\n",
    "    bp = self.phi[0].bias.data # [1, nx_rnn]\n",
    "    \n",
    "    \n",
    "    # in GPT-2 coded from HF that we are using, the input state is projected\n",
    "    # to 3 dimensions and then split to head q,k,v. This q,k,v is then split\n",
    "    # into \"d\" parts (# of heads). This \"d\" heads are then passed through the\n",
    "    # phi layer. Now when we try to fuse the weights, we hit wrong matrix\n",
    "    # multiplication [E,E] * [Eh,Er] where:\n",
    "    # * E:  config.n_embd\n",
    "    # * Eh: config.n_embd // config.n_head\n",
    "    # * Er: config.n_rnn (k-features from paper)\n",
    "    # thus we tile the phi layer config.n_head times and then fuse\n",
    "    wp = torch.tile(wp, [config.n_head, 1]) # [n_embd, nx_rnn]\n",
    "    \n",
    "    # We don't need to tile the biases because it will anyways be a vector\n",
    "    # bp = torch.tile(bp, [config.n_head, 1])\n",
    "    \n",
    "    # cache the phi function weights and biases\n",
    "    wpq = wq @ wp      # [n_embd, nx_rnn]\n",
    "    bpq = bp + bq @ wp # [n_head, nx_rnn]\n",
    "    wpk = wk @ wp\n",
    "    bpk = bp + bk @ wp\n",
    "    \n",
    "    # define the phi layer functions\n",
    "    self.v_layer = lambda x: x @ wv + bv\n",
    "    self.phi_q = lambda x: torch.relu(x @ wpq + bpq)\n",
    "    self.phi_k = lambda x: torch.relu(x @ wpk + bpk)\n",
    "    \n",
    "    # set flag that optimisation for inference is complete\n",
    "    self.infer_ready = True\n",
    "  \n",
    "  def forward(self, x, rnn_state):\n",
    "    assert self.infer_ready, \"module not prepared for inference, run .prepare_infer()\"\n",
    "    \n",
    "    # get q,k,v\n",
    "    q = self.phi_q(x)\n",
    "    k = self.phi_k(x)\n",
    "    v = self.v_layer(x)\n",
    "    \n",
    "    # from previous state we get S and z for t-1\n",
    "    s, z = rnn_state\n",
    "    s = s + k.permute((0, 2, 1)) @ v\n",
    "    z = z + k\n",
    "    \n",
    "    # get output\n",
    "    num = q @ s\n",
    "    dem = q @ z.permute((0, 2, 1))\n",
    "    out = num / dem\n",
    "    \n",
    "    return out, (s, z)\n",
    "  \n",
    "# # test code:\n",
    "# attn = RNNAttention(tinyconf)\n",
    "# attn.load_state_dict(t2r.h[0].attn.state_dict())\n",
    "# attn.infer_init()\n",
    "\n",
    "# # generate for 10 steps\n",
    "# B, E = 3, tinyconf.n_embd\n",
    "# rnn_state = [0, 0] # initial state is 0\n",
    "# for _ in range(10):\n",
    "#   hidden_state, rnn_state = attn(torch.randn(3, 1, 8), rnn_state)\n",
    "#   print(hidden_state.shape, [x.shape for x in rnn_state])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "440f0933",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Block(nn.Module):\n",
    "  def __init__(self, config):\n",
    "    super().__init__()\n",
    "    \n",
    "    inner_dim = config.n_inner if config.n_inner is not None else 4 * config.n_embd\n",
    "    self.ln_1 = nn.LayerNorm(config.n_embd, eps=config.layer_norm_epsilon)\n",
    "    self.attn = RNNAttention(config)\n",
    "    # self.attn = gpt2.modeling_gpt2.Attention(config.n_embd, config.n_ctx, config)\n",
    "    self.ln_2 = nn.LayerNorm(config.n_embd, eps=config.layer_norm_epsilon)\n",
    "    self.mlp = gpt2.modeling_gpt2.MLP(inner_dim, config)\n",
    "    \n",
    "  def infer_init(self):\n",
    "    self.attn.infer_init()\n",
    "    \n",
    "  def forward(self, hidden_states, rnn_state):\n",
    "    attn_outputs, rnn_state = self.attn(self.ln_1(hidden_states), rnn_state)\n",
    "    if isinstance(attn_outputs, tuple):\n",
    "      attn_outputs = attn_outputs[0]\n",
    "    # NOTE: this operation is not correct and will cause errors during loss.backward()\n",
    "    # hidden_states += attn_outputs\n",
    "    # because \"+=\" causes inplace update and not create a new variable meaning that\n",
    "    # nodes from the graph will be missing.\n",
    "    hidden_states = hidden_states + attn_outputs\n",
    "    mlp_states = self.mlp(self.ln_2(hidden_states))\n",
    "    hidden_states = hidden_states +  mlp_states\n",
    "    return hidden_states, rnn_state\n",
    "  \n",
    "class T2RInfer(nn.Module):\n",
    "  def __init__(self, config):\n",
    "    super().__init__()\n",
    "    \n",
    "    self.wte = nn.Embedding(config.vocab_size, config.n_embd)\n",
    "    self.wpe = nn.Embedding(config.n_positions, config.n_embd)\n",
    "    self.drop = nn.Dropout(config.embd_pdrop)\n",
    "    self.h = nn.ModuleList([Block(config) for _ in range(config.n_layer)])\n",
    "    self.ln_f = nn.LayerNorm(config.n_embd, eps=config.layer_norm_epsilon)\n",
    "    self.lm_head = nn.Linear(config.n_embd, config.vocab_size, bias = False)\n",
    "    \n",
    "    self.infer_ready = False # flag\n",
    "    self.infer_init()\n",
    "    \n",
    "    \n",
    "  def infer_init(self):\n",
    "    print(\"Preparing Model for inference\")\n",
    "    for block in self.h:\n",
    "      block.infer_init()\n",
    "    self.infer_ready = True\n",
    "    \n",
    "  @staticmethod\n",
    "  def top_k_logits(logits, k):\n",
    "    v, ix = torch.topk(logits, k)\n",
    "    out = logits.clone()\n",
    "    out[out < v[:, [-1]]] = -1e10\n",
    "    return out\n",
    "  \n",
    "  def forward(self, hstate, rnn_state):\n",
    "    for block in self.h:\n",
    "      # we don't need the outputs of the model for all these tokens only\n",
    "      # the RNN states\n",
    "      logits, rnn_state = block(hstate, rnn_state)\n",
    "    logits = self.lm_head(self.ln_f(logits))\n",
    "    return logits, rnn_state\n",
    "  \n",
    "  def get_next_tokens(self, logits, top_k, do_sample, num_return_sequences):\n",
    "    if top_k is not None:\n",
    "      logits = self.top_k_logits(logits, top_k)\n",
    "    probs = F.softmax(logits, dim=-1)[:, -1, :]\n",
    "    \n",
    "    if do_sample:\n",
    "      ix = torch.multinomial(probs, num_samples=num_return_sequences)\n",
    "    else:\n",
    "      _, ix = torch.topk(probs, k=num_return_sequences, dim=-1)\n",
    "    \n",
    "    return ix\n",
    "    \n",
    "\n",
    "     \n",
    "  @torch.no_grad()\n",
    "  def generate(\n",
    "    self,\n",
    "    input_ids,\n",
    "    max_length,\n",
    "    num_return_sequences = 1,\n",
    "    top_k = None,\n",
    "    do_sample = False\n",
    "  ):\n",
    "    assert self.infer_ready, \"Not ready for inference. see `T2RInfer.infer_init()`\"\n",
    "    \n",
    "    # if just a sequence, batchify\n",
    "    if len(input_ids.shape) == 1:\n",
    "      input_ids = input_ids.unsqueeze(0)\n",
    "      \n",
    "    # since the hidden states for all `num_return_sequences` will be same\n",
    "    # we first run those and then tile\n",
    "    B, S = input_ids.shape\n",
    "    \n",
    "    assert B == 1, \"Only 1 sequence at a time can be generated\"\n",
    "    \n",
    "    # we get position embeddings for max_length so we don't have to fetch\n",
    "    # these values again and again for each step\n",
    "    position_ids = torch.arange(0, max_length).long().unsqueeze(0)\n",
    "    position_embeds = self.wpe(position_ids)\n",
    "    inputs_embeds = self.wte(input_ids)\n",
    "\n",
    "    # go over each token in the input sequence\n",
    "    hidden_states = inputs_embeds + position_embeds[:, :S] # [B, S]\n",
    "    rnn_state = [0,0] # initial state is always 0\n",
    "    for i in range(S):\n",
    "      hstate = hidden_states[:, i].unsqueeze(1)\n",
    "      logits, rnn_state = self.forward(hstate, rnn_state)\n",
    "\n",
    "    # get the next tokens\n",
    "    ix = self.get_next_tokens(logits, top_k, do_sample, num_return_sequences)\n",
    "    generated_tokens = [ix[0]]\n",
    "\n",
    "    # tile rnn state to handle more than one sequences\n",
    "    if num_return_sequences > 1:\n",
    "      input_ids = torch.tile(input_ids, [num_return_sequences, 1])\n",
    "      rnn_state = [torch.tile(x, [num_return_sequences, 1, 1]) for x in rnn_state]\n",
    "    \n",
    "    for i in range(S, max_length - 1, 1):\n",
    "      # for rest of the steps\n",
    "      hidden_state = self.wte(generated_tokens[-1]) + position_embeds[:, i]\n",
    "      hidden_state = hidden_state.unsqueeze(1)\n",
    "      logits, rnn_state = self.forward(hidden_state, rnn_state)\n",
    "      ix = self.get_next_tokens(logits, top_k, do_sample, num_return_sequences)\n",
    "      generated_tokens.append(ix[0])\n",
    "    \n",
    "    generated_tokens = [x.unsqueeze(-1) for x in generated_tokens]\n",
    "    generated_tokens = torch.cat(generated_tokens, dim = 1)\n",
    "    full_seq = torch.cat([input_ids, generated_tokens], dim = 1)\n",
    "    return full_seq"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "9b23c06c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Preparing Model for inference\n",
      "Ready\n"
     ]
    }
   ],
   "source": [
    "t2rinfer = T2RInfer(tinyconf)\n",
    "t2rinfer.load_state_dict(t2r.state_dict())\n",
    "t2rinfer.eval()\n",
    "print(\"Ready\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "a7d26e2c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CPU times: user 110 ms, sys: 36.4 ms, total: 147 ms\n",
      "Wall time: 114 ms\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "input_ids = ds[0][0][:10].unsqueeze(0)\n",
    "output = t2rinfer.generate(\n",
    "  input_ids = input_ids,\n",
    "  max_length= 100,\n",
    "  num_return_sequences = 10,\n",
    "  do_sample = True\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "433c8189",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Input Sequence:\n",
      "this artic\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "['this artic00p9lg65bw879j91w8vgvkoqir ljmz3j4e78e2n27kxeue270rorjm2slx5ivxz2ltl2ool5qifqg s126ahonlsa',\n",
       " 'this articvt\\n1bpjxmuunm\\n z3vc628ttovfyb9yjkw2arhndpi\\nbba13ojtcy2p\\neg w1iqt1brhgtqp\\necnwibu38csu4umc1',\n",
       " 'this articw cbwd9qqrq1v88dksniojan x3af p4piwwka7f48g2ptznx4fglc9eke6\\nlcj0b48q nis0dgo2xhz 7mqll9 9l',\n",
       " 'this articpuh29afpr4dokscpvnd96dpuzlc7gx8v qdlx6gr50  w7rmw mses3tw0fnsz1\\na7waajjjt9ptl0q2ibn7mdap g',\n",
       " 'this articowon m21x2s6b3t88u9dscygrtqmmw0cr83e60vmekd7\\nxbs8as6btjum81acnf9hmzk9eu8qserxj9n0ixnw7lhd2',\n",
       " 'this artickmbqawuegmx qcxmuoxfm535t8arkr68dkr8yjhqlm99i9qkktd33m2s820rf0c 8860fpp0dyuejt67hcyu\\nueglq',\n",
       " 'this artic4xzv4khyy743wn0w9i\\n8pshfv\\nj 3qjlfmvzloronseq7psle7u5kyd1 633jjmk0x371u83a2l\\n5\\n8gf623dgm3xf',\n",
       " 'this artic fq457xf75y\\ntzysbmmekuvepnduiis5\\neyq 5wb06lwje89nfvza94054k9x75bvd036w2tkn3aasf\\nmoqmi61bfv',\n",
       " 'this artichduz0ckj01 sa7bja2jq02096d1keoxf8pko7n4us4jaazkqsl\\nazu5j0tr0ywu7mk78jcfg9m2178voq3lvr jrn\\n',\n",
       " 'this artic\\nld0mhptw\\nh065k7pllc\\nvllg9yhcbemaoftswlg1ca53k5ea\\nxv58svrwgtvrgj\\na wnhz6sjzjcllp8kke3s3sei']"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "print(\"Input Sequence:\")\n",
    "print(\"\".join([inv_vocab[x.item()] for x in input_ids[0]]))\n",
    "[\"\".join([inv_vocab[x] for x in  seq]) for seq in output.tolist()]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "50797f32",
   "metadata": {},
   "source": [
    "## Tests\n",
    "\n",
    "We will now create mid size networks w/o training and see the time taken across a bunch of experiments"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "1cb39565",
   "metadata": {},
   "outputs": [],
   "source": [
    "from time import time"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "294fce77",
   "metadata": {},
   "outputs": [],
   "source": [
    "tinyconf = GPT2Config(\n",
    "  vocab_size=vocab_size,\n",
    "  n_positions=1024,\n",
    "  n_ctx=1024,\n",
    "  n_embd=128,\n",
    "  n_layer=12,\n",
    "  n_head=8\n",
    ")\n",
    "text_lengths = np.linspace(50, 1024, 100).astype(int)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "e134720a",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2515456"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# starting with GPT-2 from HF\n",
    "model = GPT2LMHeadModel(tinyconf)\n",
    "model.eval()\n",
    "model.num_parameters()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "c6b108be",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 100/100 [28:43<00:00, 17.23s/it]\n"
     ]
    }
   ],
   "source": [
    "time_per_seq_hf = {}\n",
    "for _, max_length in zip(trange(len(text_lengths)), text_lengths):\n",
    "  st = time()\n",
    "  outputs = model.generate(\n",
    "    input_ids = ds[0][0][:10].unsqueeze(0),\n",
    "    max_length=max_length,\n",
    "    do_sample=True,\n",
    "    num_return_sequences=10,\n",
    "    pad_token_id = 12\n",
    "  )\n",
    "  time_per_seq_hf[max_length] = time() - st"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "23fdf88d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Preparing Model for inference\n",
      "\n"
     ]
    }
   ],
   "source": [
    "t2rinfer = T2RInfer(tinyconf)\n",
    "t2rinfer.eval()\n",
    "print(\"\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "0aea2b2f",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 100/100 [05:10<00:00,  3.10s/it]\n"
     ]
    }
   ],
   "source": [
    "time_per_seq_t2r = {}\n",
    "input_ids = ds[0][0][:10].unsqueeze(0)\n",
    "for _, max_length in zip(trange(len(text_lengths)), text_lengths):\n",
    "  st = time()\n",
    "  output = t2rinfer.generate(\n",
    "    input_ids = input_ids,\n",
    "    max_length= max_length,\n",
    "    num_return_sequences = 10,\n",
    "    do_sample = True\n",
    "  )\n",
    "  time_per_seq_t2r[max_length] = time() - st"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "8551b8c0",
   "metadata": {},
   "outputs": [],
   "source": [
    "hftime = list(time_per_seq_hf.values())\n",
    "trtime = list(time_per_seq_t2r.values())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "id": "c6770eea",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1440x576 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# create plots\n",
    "plt.figure(figsize = (20, 8))\n",
    "plt.plot(hftime)\n",
    "plt.plot(trtime)\n",
    "plt.ylabel(\"Time in Seconds\")\n",
    "plt.xticks(\n",
    "  ticks = np.arange(len(text_lengths) // 2) * 2,\n",
    "  labels = text_lengths[np.arange(0, len(text_lengths), 2)],\n",
    "  rotation = 90\n",
    ")\n",
    "plt.xlabel(\"Sequence Length to Generate\")\n",
    "plt.legend([\"GPT2LMHeadModel.generate()\", \"T2RInfer.generate()\"])\n",
    "plt.title(\"Time taken to generate different sequence lengths given 10 input tokens\")\n",
    "plt.savefig(\"./raw_time.png\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "id": "505ef873",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1440x576 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "hftime = np.array(hftime)\n",
    "trtime = np.array(trtime)\n",
    "\n",
    "hfy = text_lengths / hftime\n",
    "t2ry = text_lengths / trtime\n",
    "plt.figure(figsize = (20, 8))\n",
    "plt.plot(hfy)\n",
    "plt.plot(t2ry)\n",
    "plt.ylabel(\"Tokens / Second\")\n",
    "plt.xticks(\n",
    "  ticks = np.arange(len(text_lengths) // 2) * 2,\n",
    "  labels = text_lengths[np.arange(0, len(text_lengths), 2)],\n",
    "  rotation = 90\n",
    ")\n",
    "plt.xlabel(\"Sequence Length to Generate\")\n",
    "plt.legend([\"GPT2LMHeadModel.generate()\", \"T2RInfer.generate()\"])\n",
    "plt.title(\"Tokens per second generated given 10 input tokens\")\n",
    "plt.savefig(\"./tokpsec.png\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "465fa0ee",
   "metadata": {},
   "source": [
    "### It works\n",
    "\n",
    "So we can see that according to these metics T2R is better than raw transformer. In the next set of experiments we will compare this to quantized models and finally with `Intel OpenVino`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a808159e",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}
